home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Demos / OOFILE / Buildable, limited OOFILE / OOFILE partial source / oof2.cpp < prev    next >
Encoding:
Text File  |  1995-09-25  |  15.2 KB  |  754 lines  |  [TEXT/CWIE]
  1. // COPYRIGHT 1994 A.D. Software, All rights reserved
  2.  
  3. // backend parent layer of OOFILE database
  4.  
  5. #include "oof2.hpp"
  6.  
  7. // static variables
  8. dbRelChain* OOF_mixRelChainEndPoint::sTransitoryRelChainLinks;
  9. char OOF_String::sEmptyStr = '\0';
  10.  
  11.  
  12. // -------------------------------------------------------
  13. //           O O F _ t a b l e  B a c k e n d 
  14. // -------------------------------------------------------
  15. OOF_tableBackend::OOF_tableBackend(const OOF_tableBackend& rhs, const OOF_Dictionary& tablesFields) :
  16.                                     mFields(tablesFields),
  17.                                     mTableName(rhs.mTableName),
  18.                            mDirty(false)
  19. {
  20. //    mTableName = rhs.mTableName;
  21.     mOIDfield = rhs.mOIDfield;  // NOT YET IMPLEMENTED - fix this, it shouldn't be copied!
  22. }
  23.  
  24. // PUT BACK INLINE LATER
  25. void OOF_tableBackend::setOIDfield(const dbField &oidfield)
  26. {
  27.     mOIDfield = (dbField *) &oidfield; // should use const_cast as not changing
  28. }
  29.  
  30.  
  31. // PUT BACK INLINE LATER
  32. bool OOF_tableBackend::isDirty() const
  33. {
  34.         return mDirty;
  35. }
  36.  
  37.  
  38.  
  39.     
  40.  
  41. // -------------------------------------------------------
  42. //  O O F _ E x p a n d a b l e L o n g A r r a y
  43. // -------------------------------------------------------
  44. OOF_ExpandableLongArray::OOF_ExpandableLongArray(unsigned long defaultValue, unsigned long numSlots, unsigned int expandBySlots) :
  45.                                 mBits(0),
  46.                                 mDefaultValue(defaultValue),
  47.                                 mNextFreeEntry(0),
  48.                                 mNumSlots(0),
  49.                                 mExpansionChunk(expandBySlots)
  50. {
  51.     if (mExpansionChunk<1)
  52.         mExpansionChunk = 1;
  53.     if (numSlots) 
  54.     {
  55.         mNumSlots = ((numSlots-1) / expandBySlots + 1) * expandBySlots;
  56.         mBits = new unsigned long[mNumSlots];
  57.     }
  58.     CreateArrayRefCount();
  59. }
  60.  
  61.  
  62. OOF_ExpandableLongArray::OOF_ExpandableLongArray(const OOF_ExpandableLongArray& rhs) 
  63. {
  64.     mBits = rhs.mBits;
  65.     mDefaultValue = rhs.mDefaultValue;
  66.     mNextFreeEntry = rhs.mNextFreeEntry;    
  67.     mNumSlots = rhs.mNumSlots;
  68.     mInternalIter = 0;
  69.     mExpansionChunk = rhs.mExpansionChunk;
  70.     mArrayRefCount = rhs.mArrayRefCount;
  71. // inc storage refs
  72.     *mArrayRefCount += 1;
  73. }
  74.  
  75.  
  76. OOF_ExpandableLongArray& OOF_ExpandableLongArray::operator=(const OOF_ExpandableLongArray& rhs) 
  77. {
  78.     if ((this == &rhs) || (mBits == rhs.mBits))
  79.         return *this;
  80.     
  81.     DeleteBits();
  82.     mBits = rhs.mBits;
  83.     mDefaultValue = rhs.mDefaultValue;
  84.     mNextFreeEntry = rhs.mNextFreeEntry;    
  85.     mNumSlots = rhs.mNumSlots;
  86.     mInternalIter = 0;
  87.     mExpansionChunk = rhs.mExpansionChunk;
  88.     mArrayRefCount = rhs.mArrayRefCount;
  89. // inc storage refs
  90.     *mArrayRefCount += 1;
  91.     return *this;
  92. }
  93.  
  94.  
  95. void OOF_ExpandableLongArray::copyContents(const OOF_ExpandableLongArray& rhs)
  96. {
  97. #ifdef OOF_SmartHeap
  98.     MemPoolCheck(MemDefaultPool);
  99. #endif
  100.     DeleteBits();
  101.     mNumSlots=rhs.mNumSlots;  
  102.     mBits = new unsigned long[mNumSlots];
  103.     assert(mBits);
  104.     memcpy(mBits, rhs.mBits, sizeof(mBits));
  105. #ifdef OOF_SmartHeap
  106.     MemPoolCheck(MemDefaultPool);
  107. #endif
  108.     CreateArrayRefCount();
  109. }
  110.  
  111.  
  112. OOF_ExpandableLongArray::~OOF_ExpandableLongArray() 
  113. {
  114.     DeleteBits();
  115. }
  116.  
  117.  
  118. void OOF_ExpandableLongArray::DeleteBits() 
  119. {
  120.     *mArrayRefCount-=1;
  121.     if (!*mArrayRefCount) {
  122.             delete[] mBits;
  123.             delete mArrayRefCount;
  124.     }
  125. }
  126.  
  127.  
  128. void OOF_ExpandableLongArray::CreateArrayRefCount()
  129. {
  130.     mArrayRefCount = new int;
  131.     assert(mArrayRefCount);
  132.     *mArrayRefCount = 1;
  133. }
  134.  
  135.  
  136. void OOF_ExpandableLongArray::append(unsigned long aBit)  {
  137.     operator[](mNextFreeEntry) = aBit;
  138.     mNextFreeEntry++;
  139. }
  140.  
  141.  
  142. void OOF_ExpandableLongArray::deleteCell(unsigned long index)  {
  143. #ifdef OOF_SmartHeap
  144.     MemPoolCheck(MemDefaultPool);
  145. #endif
  146.     for (unsigned long i=index; i<mNextFreeEntry; i++)
  147.         mBits[i] = mBits[i+1];
  148. #ifdef OOF_SmartHeap
  149.     MemPoolCheck(MemDefaultPool);
  150. #endif
  151.     mNextFreeEntry--;
  152.     mBits[mNextFreeEntry] = mDefaultValue;
  153. }
  154.  
  155.  
  156. void OOF_ExpandableLongArray::deleteAllCells()  {
  157.     mNextFreeEntry=0;
  158. // NOT YET IMPLEMENTED - delete mBits if past threshold
  159. }
  160.  
  161.  
  162. unsigned long& OOF_ExpandableLongArray::operator[](unsigned long index)
  163. {
  164. #ifdef OOF_SmartHeap
  165.     MemPoolCheck(MemDefaultPool);
  166. #endif
  167.     if (index >= mNumSlots)
  168.         ExpandToInclude(index);
  169.     return mBits[index];
  170. }
  171.  
  172.  
  173. unsigned long OOF_ExpandableLongArray::value(unsigned long index) const
  174. {
  175.     assert (index < mNumSlots);
  176.     return mBits[index];
  177. }
  178.  
  179.  
  180. void OOF_ExpandableLongArray::ExpandToInclude(unsigned long indexToCover)
  181. {
  182. // expand the storage to include the specified index
  183. // (ie: expand to the next chunk multiple >= indexToCover
  184.     unsigned int newSize = (indexToCover / mExpansionChunk + 1) * mExpansionChunk;
  185.     unsigned long *oldBits = mBits;
  186.     mBits = new unsigned long[newSize];
  187. // NOT YET IMPLEMENTED - need error handling here
  188.  
  189.     assert(mBits);
  190.     if (oldBits) {
  191.         for (unsigned long i=0; i<mNextFreeEntry; i++)
  192.             mBits[i] = oldBits[i];
  193.         delete[] oldBits;
  194.     }
  195. #ifdef OOF_SmartHeap
  196.     MemPoolCheck(MemDefaultPool);
  197. #endif
  198.     for (unsigned long i=mNextFreeEntry; i<newSize; i++)
  199.         mBits[i] = mDefaultValue;
  200.     mNumSlots = newSize;
  201. #ifdef OOF_SmartHeap
  202.     MemPoolCheck(MemDefaultPool);
  203. #endif
  204. }
  205.  
  206.  
  207.  
  208. // -------------------------------------------------------
  209. //                 O O F _ D i c t r e p
  210. // -------------------------------------------------------
  211. void OOF_DictRep::Append(OOF_bitPointer aBit)  {
  212.     operator[](mNextFreeEntry) = aBit;
  213.     mNextFreeEntry++;
  214. }
  215.  
  216.  
  217. void OOF_DictRep::Reset()  
  218. {
  219.     mNextFreeEntry=0;
  220. } 
  221.  
  222.  
  223. OOF_DictRep::OOF_DictRep(unsigned int numSlots, unsigned int expandBySlots) : 
  224.                                 mBits(0),
  225.                                 mExpansionChunk(expandBySlots),
  226.                                 mNextFreeEntry(0),
  227.                                 mNumSlots(0)
  228. {
  229.     if (mExpansionChunk<1)
  230.         mExpansionChunk = 1;
  231.     if (numSlots) 
  232.     {
  233.         mNumSlots = ((numSlots-1) / expandBySlots + 1) * expandBySlots;
  234.         mBits = new OOF_bitPointer[mNumSlots];
  235.         assert(mBits);
  236.     }
  237. }
  238.  
  239.  
  240. OOF_DictRep::OOF_DictRep(const OOF_DictRep* rhs) : 
  241.                                 mBits(0),
  242.                                 mExpansionChunk(rhs->mExpansionChunk),
  243.                                 mNextFreeEntry(rhs->mNextFreeEntry),
  244.                                 mNumSlots(rhs->mNumSlots)
  245. {
  246.     if (mNumSlots) 
  247.     {
  248.         mBits = new OOF_bitPointer[mNumSlots];
  249.         assert(mBits);
  250.         for (unsigned long i=0; i<mNumSlots; i++)
  251.             mBits[i] = rhs->mBits[i];
  252. #ifdef OOF_SmartHeap
  253.     MemPoolCheck(MemDefaultPool);
  254. #endif
  255.     }
  256. }
  257.  
  258.  
  259. OOF_DictRep::~OOF_DictRep() 
  260. {
  261.     if (mNumSlots)
  262.         delete[] mBits;
  263. }
  264.  
  265.  
  266. OOF_bitPointer& OOF_DictRep::operator[](unsigned int index)
  267. {
  268. #ifdef OOF_SmartHeap
  269.     MemPoolCheck(MemDefaultPool);
  270. #endif
  271. #ifdef OOF_Debug
  272.     if (index > mNumSlots) {
  273.         cout << "OOF_DictRep::operator[] skipped a cell - suspect index" << endl;
  274.         assert(0);
  275.     }    
  276. #endif
  277.     if (index >= mNumSlots)
  278.         ExpandToInclude(index);
  279.     return mBits[index];
  280. }
  281.  
  282.  
  283. OOF_bitPointer& OOF_DictRep::operator[](const char *name)
  284. {
  285.     return mBits[0];  // NOT YET IMPLEMENTED
  286. }
  287.  
  288.  
  289. OOF_bitPointer OOF_DictRep::value(unsigned int index) const
  290. { 
  291.     assert(index < mNumSlots);
  292.     return mBits[index];
  293. }
  294.  
  295.  
  296.  
  297.  
  298. void OOF_DictRep::ExpandToInclude(unsigned int indexToCover) 
  299. {
  300.     unsigned int newSize = (indexToCover / mExpansionChunk + 1) * mExpansionChunk;
  301.     OOF_bitPointer *oldBits = mBits;
  302.     mBits = new OOF_bitPointer[newSize];
  303. // NOT YET IMPLEMENTED - need error handling here
  304.  
  305.     assert(mBits);
  306. #ifdef OOF_SmartHeap
  307.     MemPoolCheck(MemDefaultPool);
  308. #endif
  309.     if (oldBits) {
  310.         for (unsigned long i=0; i<mNextFreeEntry; i++)
  311.             mBits[i] = oldBits[i];
  312.         delete[] oldBits;
  313.     }
  314. #ifdef OOF_SmartHeap
  315.     MemPoolCheck(MemDefaultPool);
  316. #endif
  317.     for (unsigned long i=mNextFreeEntry; i<newSize; i++)
  318.         mBits[i] = 0;
  319. #ifdef OOF_SmartHeap
  320.     MemPoolCheck(MemDefaultPool);
  321. #endif
  322.     mNumSlots = newSize;
  323. }
  324.  
  325.  
  326.  
  327. // -------------------------------------------------------
  328. //               O O F _ D i c t i o n a r y
  329. // -------------------------------------------------------
  330. OOF_Dictionary::OOF_Dictionary() : 
  331.                                                             mOwnsContents(false)
  332. {
  333.     mRep = new OOF_DictRep(0, kDefExpansionChunk);
  334. }
  335.  
  336.  
  337. OOF_Dictionary::OOF_Dictionary(const OOF_DictRep* rep) : 
  338.                                                             mOwnsContents(false)
  339. {
  340.     mRep = new OOF_DictRep(rep);
  341. }
  342.  
  343.  
  344. OOF_Dictionary::OOF_Dictionary(unsigned int numSlots) : 
  345.                                                             mOwnsContents(false)
  346. { 
  347.     mRep = new OOF_DictRep(numSlots, kDefExpansionChunk);
  348. }
  349.  
  350.  
  351. OOF_Dictionary::OOF_Dictionary(unsigned int numSlots, unsigned int expansionChunk) : 
  352.                                                             mOwnsContents(false)
  353. {
  354.     mRep = new OOF_DictRep(numSlots, expansionChunk);
  355. }
  356.  
  357.  
  358. OOF_Dictionary::OOF_Dictionary(const OOF_Dictionary& rhs)
  359. {
  360.     mRep = rhs.mRep;
  361.     mOwnsContents = rhs.mOwnsContents;
  362.     mRep->mReferences++;
  363. }
  364.  
  365.  
  366.  
  367. OOF_Dictionary::~OOF_Dictionary() 
  368. {
  369.     if (--mRep->mReferences<=0) {
  370.         if (mOwnsContents)
  371.             deleteAll();
  372.         delete mRep;
  373.     }
  374. }
  375.  
  376.  
  377. OOF_Dictionary& OOF_Dictionary::operator=(const OOF_Dictionary& rhs)
  378. {
  379.     if ((this == &rhs) || (mRep == rhs.mRep))
  380.         return *this;
  381.     
  382.     if (--mRep->mReferences<=0)
  383.         delete mRep;
  384.  
  385.     mRep = rhs.mRep;
  386.     mRep->mReferences++;
  387.     return *this;
  388. }
  389.  
  390.  
  391. OOF_Dictionary OOF_Dictionary::clone() const
  392. {
  393.     OOF_Dictionary ret(mRep);  
  394.     return ret;
  395. }
  396.  
  397.  
  398. unsigned int OOF_Dictionary::countVisible(bool wantVisible) 
  399. {
  400.     unsigned int ret=0;
  401.    unsigned int theCount = count();
  402.     for (unsigned int i=0; i<theCount; i++) {
  403.         dbClass* entry = mRep->operator[](i);
  404.         assert(entry);  // looping known entries!
  405.         if (EntryMatchesVisibility(entry, wantVisible))
  406.             ret++;
  407.     }
  408.     return ret;
  409. }
  410.  
  411.  
  412. bool OOF_Dictionary::moreVisible(bool wantVisible) 
  413. {
  414.     if (!more())
  415.         return false;
  416.     dbClass* entry=0;
  417.     while (more()) {
  418.         dbClass* entry = operator()();
  419.         assert(entry);  // looping known entries!
  420.         if (EntryMatchesVisibility(entry, wantVisible))
  421.             return true;
  422.         next();
  423.     }
  424.     return (EntryMatchesVisibility(entry, wantVisible));
  425. }
  426.  
  427.  
  428. void OOF_Dictionary::deleteAll()
  429. {
  430.   unsigned int numEntries = count();
  431.     for (unsigned int i=0; i<numEntries; i++) {
  432.         delete &item(i);
  433.         next();
  434.     }
  435. }
  436.  
  437.  
  438. void OOF_Dictionary::describe(ostream& os)
  439. {
  440.    unsigned int numEntries = count();
  441.     for (unsigned int i=0; i<numEntries; i++) {
  442.         (operator[](i))->describe(os);
  443.         next();
  444.     }
  445.     os << endl;
  446. }
  447.  
  448.  
  449. void OOF_Dictionary::describeVisible(ostream& os, bool wantVisible)
  450. {
  451.     startVisible(wantVisible);
  452.     while (moreVisible(wantVisible)) {    
  453.         (operator()())->describe(os);
  454.         nextVisible(wantVisible);
  455.     }
  456.     os << endl;
  457. }
  458.  
  459.  
  460. bool OOF_Dictionary::allObjectsMatch(OOF_Dictionary& rhs)
  461. {
  462.     if (mRep==rhs.mRep)
  463.         return true;  // trivial case of comparing aliases
  464.         
  465.     if (count() != rhs.count())
  466.         return false;
  467.     
  468.    unsigned int numEntries = count();
  469.     for (unsigned int i=0; i<numEntries; i++)
  470.         if (operator[](i) != rhs.operator[](i))
  471.             return false;
  472.             
  473.     return true;
  474. }
  475.  
  476.  
  477. // PUT BACK INLINE LATER
  478. OOF_bitPointer& OOF_Dictionary::operator[](const char *name)
  479. {
  480.     return mRep->operator[](name);
  481. }
  482.  
  483. // PUT BACK INLINE LATER
  484. OOF_bitPointer& OOF_Dictionary::operator[](unsigned int index)
  485. {
  486.     return mRep->operator[](index);
  487. }
  488.  
  489.  
  490. // -------------------------------------------------------
  491. //              O O F _ S t r i n g
  492. // -------------------------------------------------------
  493. OOF_String::OOF_String(const OOF_String& rhs)
  494. {
  495.     mLen = rhs.mLen;
  496.     if (mLen) {
  497.         mBody = new char[mLen + 1];  // room for null
  498.         assert(mBody);
  499.         strcpy(mBody, rhs.mBody);
  500. #ifdef OOF_SmartHeap
  501.         MemPoolCheck(MemDefaultPool);
  502. #endif
  503.     }
  504.     else
  505.         mBody=0;
  506. }
  507.  
  508.  
  509. OOF_String::OOF_String(const OOF_String& str1, const char *chars, const OOF_String& str3)
  510. {
  511.     unsigned int charLen = 0;
  512.     if (chars) 
  513.         charLen = strlen(chars);
  514.     mLen = str1.mLen + charLen + str3.mLen;
  515.     if (mLen==0)
  516.         mBody = 0;
  517.     else {
  518.         mBody = new char[mLen + 1];  // room for null
  519.         assert(mBody);
  520.         if (str1.mBody)
  521.             strcpy(mBody, str1.mBody);
  522.         else
  523.             mBody[0]='\0';
  524. #ifdef OOF_SmartHeap
  525.         MemPoolCheck(MemDefaultPool);
  526. #endif
  527.         if (charLen)
  528.             strcat(mBody, chars);
  529.         if (str3.mBody)
  530.             strcat(mBody, str3.mBody);
  531. #ifdef OOF_SmartHeap
  532.         MemPoolCheck(MemDefaultPool);
  533. #endif
  534.     }
  535. }
  536.  
  537.  
  538. OOF_String::OOF_String(const OOF_String& str1, const char *chars)
  539. {
  540.     unsigned int charLen = 0;
  541.     if (chars) 
  542.         charLen = strlen(chars);
  543.     mLen = str1.mLen + charLen;
  544.     if (mLen==0)
  545.         mBody = 0;
  546.     else {
  547.         mBody = new char[mLen + 1];  // room for null
  548.         assert(mBody);
  549.         if (str1.mBody)
  550.             strcpy(mBody, str1.mBody);
  551.         else
  552.             mBody[0]='\0';
  553. #ifdef OOF_SmartHeap
  554.         MemPoolCheck(MemDefaultPool);
  555. #endif
  556.         if (charLen)
  557.             strcat(mBody, chars);
  558. #ifdef OOF_SmartHeap
  559.         MemPoolCheck(MemDefaultPool);
  560. #endif
  561.     }
  562. }
  563.  
  564.  
  565. OOF_String::OOF_String(const OOF_String& str1, const char ch, const char *chars)
  566. {
  567.     const unsigned int len1 = str1.mLen;
  568.     unsigned int charLen = 0;
  569.     if (chars) 
  570.         charLen = strlen(chars);
  571.     mLen = len1 + charLen + 1;
  572.  
  573.     mBody = new char[mLen + 1];  // room for null
  574.     assert(mBody);
  575.     if (str1.mBody)
  576.         strcpy(mBody, str1.mBody);
  577.     else
  578.     mBody[len1]=ch;
  579.     mBody[len1+1]='\0';
  580. #ifdef OOF_SmartHeap
  581.     MemPoolCheck(MemDefaultPool);
  582. #endif
  583.     if (charLen)
  584.         strcat(mBody, chars);
  585. #ifdef OOF_SmartHeap
  586.     MemPoolCheck(MemDefaultPool);
  587. #endif
  588. }
  589.  
  590.  
  591. OOF_String::OOF_String(const char *chars)
  592. {
  593.     mLen = 0;
  594.     mBody = 0;
  595.     if (chars) {
  596.         mLen = strlen(chars);
  597.         if (mLen) {
  598.             mBody = new char[mLen + 1];  // room for null
  599.             assert(mBody);
  600.             strcpy(mBody, chars); 
  601.     #ifdef OOF_SmartHeap
  602.         MemPoolCheck(MemDefaultPool);
  603.     #endif
  604.         }
  605.     }
  606. }
  607.  
  608.  
  609. OOF_String::~OOF_String()
  610. {
  611.     delete [] mBody;
  612. }
  613.  
  614.  
  615. OOF_String& OOF_String::operator=(const OOF_String& rhs)
  616. {
  617.     if (*this==rhs)
  618.         return *this;
  619.         
  620.     delete[] mBody;
  621.     mLen = rhs.mLen;
  622.     if (mLen==0)
  623.         mBody = 0;
  624.     else {
  625.         mBody = new char[mLen + 1];  // room for null
  626.         assert(mBody);
  627.         strcpy(mBody, rhs.mBody);
  628. #ifdef OOF_SmartHeap
  629.         MemPoolCheck(MemDefaultPool);
  630. #endif
  631.     }
  632.     return *this;
  633. }
  634.  
  635.  
  636. OOF_String& OOF_String::operator=(const char* chars)
  637. {
  638.     delete[] mBody;
  639.     if (chars) {
  640.         mLen = strlen(chars);
  641.         mBody = new char[mLen + 1];  // room for null
  642.         assert(mBody);
  643.         strcpy(mBody, chars); 
  644. #ifdef OOF_SmartHeap
  645.     MemPoolCheck(MemDefaultPool);
  646. #endif
  647.     }
  648.     else {
  649.         mLen = 0;
  650.         mBody = 0;
  651.     }
  652.     return *this;
  653. }
  654.  
  655.  
  656. OOF_String::operator char *() const
  657. {        
  658. // WARNING this code exposes the internal container
  659. // but is safe so long as this is a read-only cast.
  660. //    char *ret;
  661.     if (mBody)
  662.         return mBody;
  663.     else
  664.         return &sEmptyStr;
  665. }
  666.  
  667.  
  668. char *OOF_String::adopt()
  669. {        
  670.     char *ret=mBody;
  671.     mBody = 0;
  672.     mLen = 0;
  673.     return ret;
  674. }
  675.  
  676.  
  677. ostream& operator<<(ostream& os, const OOF_String& str)
  678. {
  679.     os << (char*) str;
  680.     return os;
  681. }
  682.  
  683.  
  684. #ifdef _Macintosh
  685. // -------------------------------------------------------
  686. //              O O F _ M a c S t r i n g
  687. // -------------------------------------------------------
  688. OOF_MacString::OOF_MacString(const Str63 str)
  689. {
  690.     mLen = str[0];
  691.     mBody = 0;
  692.     if (mLen) {
  693.             mBody = new char[mLen + 1];  // room for null
  694.             assert(mBody);
  695.             memcpy(mBody, &(str[1]), mLen);
  696.             mBody[mLen] = '\0';
  697.     #ifdef OOF_SmartHeap
  698.         MemPoolCheck(MemDefaultPool);
  699.     #endif
  700.     }
  701. }
  702. #endif
  703.  
  704. // -------------------------------------------------------
  705. //          O O F _ I n d e x O p t i o n s
  706. // -------------------------------------------------------
  707. ostream& operator<<(ostream& os, OOF_IndexOptions opt)
  708. {
  709.     switch (opt) {
  710.     case (kNotIndexed) :
  711.         os << "not indexed";
  712.         break;
  713.         
  714.     case (kIndexed) :
  715.         os << "indexed, allowing dups & ignoring case";
  716.         break;
  717.         
  718.     case (kIndexNoDups) :
  719.         os << "indexed, no dups & ignoring case";
  720.         break;
  721.         
  722.     case (kIndexCaseSensitive) :
  723.         os << "indexed, allowing dups but case-sensitive";
  724.         break;
  725.         
  726.     case (kIndexCompressPaddingNoDups) :
  727.         os << "indexed, no dups & ignoring case, compressing padding";
  728.         break;
  729.         
  730.     case (kIndexCompressLeadingNoDups) :
  731.         os << "indexed, no dups & ignoring case, compressing front";
  732.         break;
  733.         
  734.     case (kIndexCompressNoDups) :
  735.         os << "indexed, no dups & ignoring case, compress front & padding";
  736.         break;
  737.         
  738.     case (kIndexCompress) :
  739.         os << "indexed, ignoring case, compress front & padding";
  740.         break;
  741.         
  742.     case (kIndexCompressPadding) :
  743.         os << "indexed, ignoring case, compressing padding";
  744.         break;
  745.         
  746.     case (kIndexCompressLeading) :
  747.         os << "indexed, ignoring case, compressing front";
  748.         break;
  749.         
  750.     }
  751.     return os;
  752. }
  753.  
  754.